package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade VARIAVEL_UTILIZADA_FORMULA
 * @author Gerado pelo Telescope
 */
public class EntVariavelUtilizadaFormula extends AssociativeEntity {
    
    public final static String ENTITY_NAME = "ZTEST.VARIAVEL_UTILIZADA_FORMULA";
    public final static String TABLE_NAME = "VARIAVEL_UTILIZADA_FORMULA";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntVariavelUtilizadaFormula() {
        super();
        initialize();
    }
    
    public EntVariavelUtilizadaFormula(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aFormulaExecucaoId = new DomId(this,"FORMULA_EXECUCAO_ID", "Fórmula de execução"); 
        aFormulaExecucaoId.setRequired(true);
        oFormulaExecucaoId = new DomId();
        aVariavelExecucaoId = new DomId(this,"VARIAVEL_EXECUCAO_ID", "Variável de execução"); 
        aVariavelExecucaoId.setRequired(true);
        oVariavelExecucaoId = new DomId();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Fórmula de execução
    private DomId aFormulaExecucaoId;
    private DomId oFormulaExecucaoId;
    
    // Variável de execução
    private DomId aVariavelExecucaoId;
    private DomId oVariavelExecucaoId;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntVariavelUtilizadaFormula id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo FORMULA_EXECUCAO_ID">
    
    public EntVariavelUtilizadaFormula formulaExecucaoId(Long value) {
        setFormulaExecucaoId(value);
        return this;
    }
    
    public void setFormulaExecucaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyFormulaExecucaoId();
        } else {
            aFormulaExecucaoId.setValue(value.getValue());
            if (aFormulaExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFormulaExecucaoId(String value) {
        if (value == null) {
            nullifyFormulaExecucaoId();
        } else {
            aFormulaExecucaoId.setValue(value);
            if (aFormulaExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFormulaExecucaoId(Long value) {
        aFormulaExecucaoId.setValue(value);
        if (aFormulaExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setFormulaExecucaoId(Object value) {
        aFormulaExecucaoId.setValue(value);
        if (aFormulaExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyFormulaExecucaoId() {
        if (!aFormulaExecucaoId.isNull()) {
            aFormulaExecucaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getFormulaExecucaoId() {
        return aFormulaExecucaoId;
    }
    
    public DomId oldFormulaExecucaoId() {
        return oFormulaExecucaoId;
    }
    
    public Long valueOfFormulaExecucaoId() {
        return aFormulaExecucaoId.getValue();
    }
    
    public boolean isFormulaExecucaoIdModified() {
        return aFormulaExecucaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VARIAVEL_EXECUCAO_ID">
    
    public EntVariavelUtilizadaFormula variavelExecucaoId(Long value) {
        setVariavelExecucaoId(value);
        return this;
    }
    
    public void setVariavelExecucaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyVariavelExecucaoId();
        } else {
            aVariavelExecucaoId.setValue(value.getValue());
            if (aVariavelExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVariavelExecucaoId(String value) {
        if (value == null) {
            nullifyVariavelExecucaoId();
        } else {
            aVariavelExecucaoId.setValue(value);
            if (aVariavelExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVariavelExecucaoId(Long value) {
        aVariavelExecucaoId.setValue(value);
        if (aVariavelExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setVariavelExecucaoId(Object value) {
        aVariavelExecucaoId.setValue(value);
        if (aVariavelExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyVariavelExecucaoId() {
        if (!aVariavelExecucaoId.isNull()) {
            aVariavelExecucaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getVariavelExecucaoId() {
        return aVariavelExecucaoId;
    }
    
    public DomId oldVariavelExecucaoId() {
        return oVariavelExecucaoId;
    }
    
    public Long valueOfVariavelExecucaoId() {
        return aVariavelExecucaoId.getValue();
    }
    
    public boolean isVariavelExecucaoIdModified() {
        return aVariavelExecucaoId.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            e = new AdsException("ZTEST.VARIAVEL_UTILIZADA_FORMULA.GET_ERRORS_UNKNOWN",
                    AdsException.UNKNOWN,
                    "Erro não esperado: " + errorMsg);
        } else {
            if (msg.indexOf("UK_VUNAFO_VARIAVEL") >= 0) {
                e = new AdsException("ZTEST.VARIAVEL_UTILIZADA_FORMULA.UK_VUNAFO_VARIAVEL", 
                        Severity.ERROR,
                        "Registro duplicado! A variável deve ser única para a fórmula de execução. Fórmula de execução ${FORMULA_EXECUCAO_ID}, Variável de execução ${VARIAVEL_EXECUCAO_ID} (UK_VUNAFO_VARIAVEL)");
                return e;
            } else if (msg.indexOf("FK_VUNAFO_VARIAVEL_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.VARIAVEL_UTILIZADA_FORMULA.FK_VUNAFO_VARIAVEL_EXECUCAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para VARIAVEL_EXECUCAO! (FK_VUNAFO_VARIAVEL_EXECUCAO)");
                return e;
            } else if (msg.indexOf("FK_VUNAFO_FORMULA_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.VARIAVEL_UTILIZADA_FORMULA.FK_VUNAFO_FORMULA_EXECUCAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para FORMULA_EXECUCAO! (FK_VUNAFO_FORMULA_EXECUCAO)");
                return e;
            } else if (msg.indexOf("PK_VUNAFO") >= 0) {
                e = new AdsException("ZTEST.VARIAVEL_UTILIZADA_FORMULA.PK_VUNAFO", 
                        Severity.ERROR,
                        "ID duplicado! (PK_VUNAFO)");
                return e;
            } else {
                e = new AdsException("ZTEST.VARIAVEL_UTILIZADA_FORMULA.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aFormulaExecucaoId);
            allAttributes.add(aVariavelExecucaoId);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getFormulaExecucaoId().toString() +
                " " + getVariavelExecucaoId().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    /**
     * Métodos de manipulação dos IDs das entidades associadas
     */
    public DomId getAssociationId1() {
        return getFormulaExecucaoId();
    }
    public DomId getAssociationId2() {
        return getVariavelExecucaoId();
    }
    public void setAssociationId1(long id) {
        setFormulaExecucaoId(id);
    }
    public void setAssociationId2(long id) {
        setVariavelExecucaoId(id);
    }
    
    public void findByFormulaExecucaoIdVariavelExecucaoId(long formulaExecucaoId, long variavelExecucaoId) throws AdsException {
        findBy(new String[] {"FORMULA_EXECUCAO_ID", "VARIAVEL_EXECUCAO_ID"},
                new Object[] {formulaExecucaoId, variavelExecucaoId});
    }
    
    private EntVariavelAplicativo eVariavelExecucao;
    
    public EntVariavelAplicativo findVariavelExecucao() throws AdsException {
        if (getVariavelExecucaoId().isNull()) {
            return null;
        }
        if (eVariavelExecucao == null || !valueOfVariavelExecucaoId().equals(eVariavelExecucao.valueOfId())) {
            eVariavelExecucao = new EntVariavelAplicativo(ctx);
            eVariavelExecucao.find(valueOfVariavelExecucaoId());
        }
        return eVariavelExecucao;
    }
    
    /**
     * Ativa o join desta entidade com VARIAVEL_APLICATIVO
     * através do atributo VARIAVEL_EXECUCAO_ID
     */
    public EntVariavelAplicativo joinVariavelExecucao() {
        return joinVariavelExecucao(null);
    }
    public EntVariavelAplicativo joinVariavelExecucao(String alias) {
        EntVariavelAplicativo entity = new EntVariavelAplicativo(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getVariavelExecucaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByVariavelExecucao(long id, String sqlAppend) throws AdsException {
        find("select ID from VARIAVEL_UTILIZADA_FORMULA where VARIAVEL_EXECUCAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByVariavelExecucao(long id) throws AdsException {
        findByVariavelExecucao(id,"");
    }
    
    public void findByVariavelExecucao(Entity entidade) throws AdsException {
        findByVariavelExecucao(entidade.valueOfId(),"");
    }
    
    public void findByVariavelExecucao(Entity entidade, String sqlAppend) throws AdsException {
        findByVariavelExecucao(entidade.valueOfId(),sqlAppend);
    }
    
    private EntFormulaExecucao eFormulaExecucao;
    
    public EntFormulaExecucao findFormulaExecucao() throws AdsException {
        if (getFormulaExecucaoId().isNull()) {
            return null;
        }
        if (eFormulaExecucao == null || !valueOfFormulaExecucaoId().equals(eFormulaExecucao.valueOfId())) {
            eFormulaExecucao = new EntFormulaExecucao(ctx);
            eFormulaExecucao.find(valueOfFormulaExecucaoId());
        }
        return eFormulaExecucao;
    }
    
    /**
     * Ativa o join desta entidade com FORMULA_EXECUCAO
     * através do atributo FORMULA_EXECUCAO_ID
     */
    public EntFormulaExecucao joinFormulaExecucao() {
        return joinFormulaExecucao(null);
    }
    public EntFormulaExecucao joinFormulaExecucao(String alias) {
        EntFormulaExecucao entity = new EntFormulaExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getFormulaExecucaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByFormulaExecucao(long id, String sqlAppend) throws AdsException {
        find("select ID from VARIAVEL_UTILIZADA_FORMULA where FORMULA_EXECUCAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByFormulaExecucao(long id) throws AdsException {
        findByFormulaExecucao(id,"");
    }
    
    public void findByFormulaExecucao(Entity entidade) throws AdsException {
        findByFormulaExecucao(entidade.valueOfId(),"");
    }
    
    public void findByFormulaExecucao(Entity entidade, String sqlAppend) throws AdsException {
        findByFormulaExecucao(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eVariavelExecucao = null;
        eFormulaExecucao = null;
    }
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oVariavelExecucaoId.setValue(aVariavelExecucaoId);
        oFormulaExecucaoId.setValue(aFormulaExecucaoId);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntVariavelUtilizadaFormula.class);
            rule.setName("PK_VUNAFO");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntVariavelUtilizadaFormula.class);
            rule.setAssociatedEntity(EntFormulaExecucao.class);
            rule.setName("FK_VUNAFO_FORMULA_EXECUCAO");
            rule.addAttribute(new DomId("FORMULA_EXECUCAO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntVariavelUtilizadaFormula.class);
            rule.setAssociatedEntity(EntVariavelAplicativo.class);
            rule.setName("FK_VUNAFO_VARIAVEL_EXECUCAO");
            rule.addAttribute(new DomId("VARIAVEL_EXECUCAO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntVariavelUtilizadaFormula.class);
            rule.setName("UK_VUNAFO_VARIAVEL");
            rule.addAttribute(new DomId("FORMULA_EXECUCAO_ID",""));
            rule.addAttribute(new DomId("VARIAVEL_EXECUCAO_ID",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
}
